#include <stdio.h>
#include <string.h>
#include <regex.h>

// 改进的数据脱敏函数：对敏感信息进行掩码处理
void process_data(const char* input, char* output) {
    strcpy(output, input);
    
    // 邮箱脱敏：保留邮箱前缀的首尾字符，中间用*代替
    regex_t email_regex;
    regmatch_t email_matches[10];
    if (regcomp(&email_regex, "([a-zA-Z0-9._-]+)@([a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4})", REG_EXTENDED) == 0) {
        char* ptr = output;
        while (regexec(&email_regex, ptr, 10, email_matches, 0) == 0) {
            int start = email_matches[1].rm_so;
            int end = email_matches[1].rm_eo;
            int len = end - start;
            if (len > 2) {
                for (int i = start + 1; i < end - 1; i++) {
                    ptr[i] = '*';
                }
            }
            ptr += email_matches[0].rm_eo;
        }
        regfree(&email_regex);
    }
    
    // 手机号脱敏：保留前3位和后4位，中间用****代替
    regex_t phone_regex;
    regmatch_t phone_matches[1];
    if (regcomp(&phone_regex, "1[3-9][0-9]{9}", REG_EXTENDED) == 0) {
        char* ptr = output;
        while (regexec(&phone_regex, ptr, 1, phone_matches, 0) == 0) {
            int start = phone_matches[0].rm_so;
            for (int i = start + 3; i < start + 7; i++) {
                ptr[i] = '*';
            }
            ptr += phone_matches[0].rm_eo;
        }
        regfree(&phone_regex);
    }
    
    // 身份证号脱敏：保留前6位和后4位，中间用********代替
    regex_t id_regex;
    regmatch_t id_matches[1];
    if (regcomp(&id_regex, "[1-9][0-9]{17}[0-9Xx]", REG_EXTENDED) == 0) {
        char* ptr = output;
        while (regexec(&id_regex, ptr, 1, id_matches, 0) == 0) {
            int start = id_matches[0].rm_so;
            for (int i = start + 6; i < start + 14; i++) {
                ptr[i] = '*';
            }
            ptr += id_matches[0].rm_eo;
        }
        regfree(&id_regex);
    }
    
    // 银行卡号脱敏：保留前6位和后4位，中间用****代替
    regex_t card_regex;
    regmatch_t card_matches[1];
    if (regcomp(&card_regex, "[0-9]{16,19}", REG_EXTENDED) == 0) {
        char* ptr = output;
        while (regexec(&card_regex, ptr, 1, card_matches, 0) == 0) {
            int start = card_matches[0].rm_so;
            int end = card_matches[0].rm_eo;
            int len = end - start;
            if (len >= 10) {
                for (int i = start + 6; i < end - 4; i++) {
                    ptr[i] = '*';
                }
            }
            ptr += card_matches[0].rm_eo;
        }
        regfree(&card_regex);
    }
}

// 检查是否包含手机号码
int contains_phone_number(const char* text) {
    regex_t regex;
    int reti;

    // 简单的手机号匹配规则 (中国手机号)
    reti = regcomp(&regex, "1[3-9][0-9]{9}", REG_EXTENDED);
    if (reti) {
        fprintf(stderr, "Could not compile regex\n");
        return -1;
    }

    reti = regexec(&regex, text, 0, NULL, 0);
    regfree(&regex);
    
    if (!reti) {
        return 1; // 匹配到手机号
    } else if (reti == REG_NOMATCH) {
        return 0; // 未匹配到手机号
    } else {
        return -1; // 错误
    }
}

// 检查是否包含身份证号码
int contains_id_card(const char* text) {
    regex_t regex;
    int reti;

    // 简单的身份证号匹配规则 (18位身份证号)
    reti = regcomp(&regex, "[1-9][0-9]{17}[0-9Xx]", REG_EXTENDED);
    if (reti) {
        fprintf(stderr, "Could not compile regex\n");
        return -1;
    }

    reti = regexec(&regex, text, 0, NULL, 0);
    regfree(&regex);
    
    if (!reti) {
        return 1; // 匹配到身份证号
    } else if (reti == REG_NOMATCH) {
        return 0; // 未匹配到身份证号
    } else {
        return -1; // 错误
    }
}

// 检查是否包含邮箱地址
int contains_email(const char* text) {
    regex_t regex;
    int reti;

    // 邮箱地址匹配规则
    reti = regcomp(&regex, "[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}", REG_EXTENDED);
    if (reti) {
        fprintf(stderr, "Could not compile regex\n");
        return -1;
    }

    reti = regexec(&regex, text, 0, NULL, 0);
    regfree(&regex);
    
    if (!reti) {
        return 1; // 匹配到邮箱地址
    } else if (reti == REG_NOMATCH) {
        return 0; // 未匹配到邮箱地址
    } else {
        return -1; // 错误
    }
}

// 检查是否包含银行卡号
int contains_credit_card(const char* text) {
    regex_t regex, id_regex;
    int reti;
    
    // 银行卡号匹配规则 (16-19位数字)
    reti = regcomp(&regex, "\\b[0-9]{16,19}\\b", REG_EXTENDED);
    if (reti) {
        fprintf(stderr, "Could not compile credit card regex\n");
        return -1;
    }
    
    // 身份证号匹配规则 (18位身份证号)
    reti = regcomp(&id_regex, "\\b[1-9][0-9]{17}[0-9Xx]\\b", REG_EXTENDED);
    if (reti) {
        fprintf(stderr, "Could not compile ID card regex\n");
        regfree(&regex);
        return -1;
    }
    
    // 在整个文本中查找匹配项
    regmatch_t matches[100]; // 假设文本中最多有100个匹配项
    const char* ptr = text;
    int found_credit_card = 0;
    
    // 查找所有可能的银行卡号候选
    while (regexec(&regex, ptr, 1, matches, 0) == 0) {
        int start = matches[0].rm_so;
        int end = matches[0].rm_eo;
        int len = end - start;
        
        // 提取匹配的字符串
        char matched_str[21]; // 最多19个字符 + '\0'
        if (len <= 20) {
            strncpy(matched_str, ptr + start, len);
            matched_str[len] = '\0';
            
            // 检查这个匹配项是否也符合身份证号格式
            if (regexec(&id_regex, matched_str, 0, NULL, 0) != 0) {
                // 不匹配身份证号格式，因此是银行卡号
                found_credit_card = 1;
                break;
            }
        }
        
        // 移动到下一个位置继续查找
        ptr += end;
    }
    
    regfree(&regex);
    regfree(&id_regex);
    
    return found_credit_card;
}